In server applications, processing client requests usually involves operations (e.g., CPU computations) and I/O actions. Two competing processing architectures in building a scalable server application include: (a) thread-per-request execution and (b) event-driven execution. In thread-per-request execution, one thread is assigned to execute all operations sequentially for processing a request received by the server application. This architecture is easier to construct and maintain due to widely understood sequential programming model. However, in thread-per-request execution, input/output (I/O) actions initiated by the executing operations block or stall thread processing until the initiated I/O actions upon which the thread depends are completed, after which the thread execution continues. As a result, this architecture requires the system to maintain a large amount of threads, which are resource intensive. In contrast, event-driven execution uses asynchronous I/O event handling to coordinate execution of operation groups used to process a received request. Systems constructed with architecture uses less number of threads as threads do not need to wait for I/O completion events. However, event-driven execution adds considerable programming complexity as the programmer has to manage the request handling as multiple operation groups that may run concurrently while coordinating asynchronous and potentially interdependent I/O and computation operations.